/**
 * Copyright (c) 2006-2018, JGraph Ltd
 * Copyright (c) 2006-2018, Gaudenz Alder
 */
/**
 * Class: mxCompactTreeLayout
 *
 * Extends <mxGraphLayout> to implement a compact tree (Moen) algorithm. This
 * layout is suitable for graphs that have no cycles (trees). Vertices that are
 * not connected to the tree will be ignored by this layout.
 *
 * Example:
 *
 * (code)
 * var layout = new mxCompactTreeLayout(graph);
 * layout.execute(graph.getDefaultParent());
 * (end)
 *
 * Constructor: mxCompactTreeLayout
 *
 * Constructs a new compact tree layout for the specified graph
 * and orientation.
 */
function mxCompactTreeLayout(graph, horizontal, invert)
{
    mxGraphLayout.call(this, graph);
    this.horizontal = (horizontal != null) ? horizontal : true;
    this.invert = (invert != null) ? invert : false;
};

/**
 * Extends mxGraphLayout.
 */
mxCompactTreeLayout.prototype = new mxGraphLayout();
mxCompactTreeLayout.prototype.constructor = mxCompactTreeLayout;

/**
 * Variable: horizontal
 *
 * Specifies the orientation of the layout. Default is true.
 */
mxCompactTreeLayout.prototype.horizontal = null;

/**
 * Variable: invert
 *
 * Specifies if edge directions should be inverted. Default is false.
 */
mxCompactTreeLayout.prototype.invert = null;

/**
 * Variable: resizeParent
 *
 * If the parents should be resized to match the width/height of the
 * children. Default is true.
 */
mxCompactTreeLayout.prototype.resizeParent = true;

/**
 * Variable: maintainParentLocation
 *
 * Specifies if the parent location should be maintained, so that the
 * top, left corner stays the same before and after execution of
 * the layout. Default is false for backwards compatibility.
 */
mxCompactTreeLayout.prototype.maintainParentLocation = false;

/**
 * Variable: groupPadding
 *
 * Padding added to resized parents. Default is 10.
 */
mxCompactTreeLayout.prototype.groupPadding = 10;

/**
 * Variable: groupPaddingTop
 *
 * Top padding added to resized parents. Default is 0.
 */
mxCompactTreeLayout.prototype.groupPaddingTop = 0;

/**
 * Variable: groupPaddingRight
 *
 * Right padding added to resized parents. Default is 0.
 */
mxCompactTreeLayout.prototype.groupPaddingRight = 0;

/**
 * Variable: groupPaddingBottom
 *
 * Bottom padding added to resized parents. Default is 0.
 */
mxCompactTreeLayout.prototype.groupPaddingBottom = 0;

/**
 * Variable: groupPaddingLeft
 *
 * Left padding added to resized parents. Default is 0.
 */
mxCompactTreeLayout.prototype.groupPaddingLeft = 0;

/**
 * Variable: parentsChanged
 *
 * A set of the parents that need updating based on children
 * process as part of the layout.
 */
mxCompactTreeLayout.prototype.parentsChanged = null;

/**
 * Variable: moveTree
 *
 * Specifies if the tree should be moved to the top, left corner
 * if it is inside a top-level layer. Default is false.
 */
mxCompactTreeLayout.prototype.moveTree = false;

/**
 * Variable: visited
 *
 * Specifies if the tree should be moved to the top, left corner
 * if it is inside a top-level layer. Default is false.
 */
mxCompactTreeLayout.prototype.visited = null;

/**
 * Variable: levelDistance
 *
 * Holds the levelDistance. Default is 10.
 */
mxCompactTreeLayout.prototype.levelDistance = 10;

/**
 * Variable: nodeDistance
 *
 * Holds the nodeDistance. Default is 20.
 */
mxCompactTreeLayout.prototype.nodeDistance = 20;

/**
 * Variable: resetEdges
 *
 * Specifies if all edge points of traversed edges should be removed.
 * Default is true.
 */
mxCompactTreeLayout.prototype.resetEdges = true;

/**
 * Variable: prefHozEdgeSep
 *
 * The preferred horizontal distance between edges exiting a vertex.
 */
mxCompactTreeLayout.prototype.prefHozEdgeSep = 5;

/**
 * Variable: prefVertEdgeOff
 *
 * The preferred vertical offset between edges exiting a vertex.
 */
mxCompactTreeLayout.prototype.prefVertEdgeOff = 4;

/**
 * Variable: minEdgeJetty
 *
 * The minimum distance for an edge jetty from a vertex.
 */
mxCompactTreeLayout.prototype.minEdgeJetty = 8;

/**
 * Variable: channelBuffer
 *
 * The size of the vertical buffer in the center of inter-rank channels
 * where edge control points should not be placed.
 */
mxCompactTreeLayout.prototype.channelBuffer = 4;

/**
 * Variable: edgeRouting
 *
 * Whether or not to apply the internal tree edge routing.
 */
mxCompactTreeLayout.prototype.edgeRouting = true;

/**
 * Variable: sortEdges
 *
 * Specifies if edges should be sorted according to the order of their
 * opposite terminal cell in the model.
 */
mxCompactTreeLayout.prototype.sortEdges = false;

/**
 * Variable: alignRanks
 *
 * Whether or not the tops of cells in each rank should be aligned
 * across the rank
 */
mxCompactTreeLayout.prototype.alignRanks = false;

/**
 * Variable: maxRankHeight
 *
 * An array of the maximum height of cells (relative to the layout direction)
 * per rank
 */
mxCompactTreeLayout.prototype.maxRankHeight = null;

/**
 * Variable: root
 *
 * The cell to use as the root of the tree
 */
mxCompactTreeLayout.prototype.root = null;

/**
 * Variable: node
 *
 * The internal node representation of the root cell. Do not set directly
 * , this value is only exposed to assist with post-processing functionality
 */
mxCompactTreeLayout.prototype.node = null;

/**
 * Function: isVertexIgnored
 *
 * Returns a boolean indicating if the given <mxCell> should be ignored as a
 * vertex. This returns true if the cell has no connections.
 *
 * Parameters:
 *
 * vertex - <mxCell> whose ignored state should be returned.
 */
mxCompactTreeLayout.prototype.isVertexIgnored = function(vertex)
{
    return mxGraphLayout.prototype.isVertexIgnored.apply(this, arguments) ||
        this.graph.getConnections(vertex).length == 0;
};

/**
 * Function: isHorizontal
 *
 * Returns <horizontal>.
 */
mxCompactTreeLayout.prototype.isHorizontal = function()
{
    return this.horizontal;
};

/**
 * Function: execute
 *
 * Implements <mxGraphLayout.execute>.
 *
 * If the parent has any connected edges, then it is used as the root of
 * the tree. Else, <mxGraph.findTreeRoots> will be used to find a suitable
 * root node within the set of children of the given parent.
 *
 * Parameters:
 *
 * parent - <mxCell> whose children should be laid out.
 * root - Optional <mxCell> that will be used as the root of the tree.
 * Overrides <root> if specified.
 */
mxCompactTreeLayout.prototype.execute = function(parent, root)
{
    this.parent = parent;
    var model = this.graph.getModel();

    if (root == null)
    {
        // Takes the parent as the root if it has outgoing edges
        if (this.graph.getEdges(parent, model.getParent(parent),
            this.invert, !this.invert, false).length > 0)
        {
            this.root = parent;
        }

        // Tries to find a suitable root in the parent's
        // children
        else
        {
            var roots = this.graph.findTreeRoots(parent, true, this.invert);

            if (roots.length > 0)
            {
                for (var i = 0; i < roots.length; i++)
                {
                    if (!this.isVertexIgnored(roots[i]) &&
                        this.graph.getEdges(roots[i], null,
                            this.invert, !this.invert, false).length > 0)
                    {
                        this.root = roots[i];
                        break;
                    }
                }
            }
        }
    }
    else
    {
        this.root = root;
    }

    if (this.root != null)
    {
        if (this.resizeParent)
        {
            this.parentsChanged = new Object();
        }
        else
        {
            this.parentsChanged = null;
        }

        //  Maintaining parent location
        this.parentX = null;
        this.parentY = null;

        if (parent != this.root && model.isVertex(parent) != null && this.maintainParentLocation)
        {
            var geo = this.graph.getCellGeometry(parent);

            if (geo != null)
            {
                this.parentX = geo.x;
                this.parentY = geo.y;
            }
        }

        model.beginUpdate();

        try
        {
            this.visited = new Object();
            this.node = this.dfs(this.root, parent);

            if (this.alignRanks)
            {
                this.maxRankHeight = [];
                this.findRankHeights(this.node, 0);
                this.setCellHeights(this.node, 0);
            }

            if (this.node != null)
            {
                this.layout(this.node);
                var x0 = this.graph.gridSize;
                var y0 = x0;

                if (!this.moveTree)
                {
                    var g = this.getVertexBounds(this.root);

                    if (g != null)
                    {
                        x0 = g.x;
                        y0 = g.y;
                    }
                }

                var bounds = null;

                if (this.isHorizontal())
                {
                    bounds = this.horizontalLayout(this.node, x0, y0);
                }
                else
                {
                    bounds = this.verticalLayout(this.node, null, x0, y0);
                }

                if (bounds != null)
                {
                    var dx = 0;
                    var dy = 0;

                    if (bounds.x < 0)
                    {
                        dx = Math.abs(x0 - bounds.x);
                    }

                    if (bounds.y < 0)
                    {
                        dy = Math.abs(y0 - bounds.y);
                    }

                    if (dx != 0 || dy != 0)
                    {
                        this.moveNode(this.node, dx, dy);
                    }

                    if (this.resizeParent)
                    {
                        this.adjustParents();
                    }

                    if (this.edgeRouting)
                    {
                        // Iterate through all edges setting their positions
                        this.localEdgeProcessing(this.node);
                    }
                }

                // Maintaining parent location
                if (this.parentX != null && this.parentY != null)
                {
                    var geo = this.graph.getCellGeometry(parent);

                    if (geo != null)
                    {
                        geo = geo.clone();
                        geo.x = this.parentX;
                        geo.y = this.parentY;
                        model.setGeometry(parent, geo);
                    }
                }
            }
        }
        finally
        {
            model.endUpdate();
        }
    }
};

/**
 * Function: moveNode
 *
 * Moves the specified node and all of its children by the given amount.
 */
mxCompactTreeLayout.prototype.moveNode = function(node, dx, dy)
{
    node.x += dx;
    node.y += dy;
    this.apply(node);

    var child = node.child;

    while (child != null)
    {
        this.moveNode(child, dx, dy);
        child = child.next;
    }
};


/**
 * Function: sortOutgoingEdges
 *
 * Called if <sortEdges> is true to sort the array of outgoing edges in place.
 */
mxCompactTreeLayout.prototype.sortOutgoingEdges = function(source, edges)
{
    var lookup = new mxDictionary();

    edges.sort(function(e1, e2)
    {
        var end1 = e1.getTerminal(e1.getTerminal(false) == source);
        var p1 = lookup.get(end1);

        if (p1 == null)
        {
            p1 = mxCellPath.create(end1).split(mxCellPath.PATH_SEPARATOR);
            lookup.put(end1, p1);
        }

        var end2 = e2.getTerminal(e2.getTerminal(false) == source);
        var p2 = lookup.get(end2);

        if (p2 == null)
        {
            p2 = mxCellPath.create(end2).split(mxCellPath.PATH_SEPARATOR);
            lookup.put(end2, p2);
        }

        return mxCellPath.compare(p1, p2);
    });
};

/**
 * Function: findRankHeights
 *
 * Stores the maximum height (relative to the layout
 * direction) of cells in each rank
 */
mxCompactTreeLayout.prototype.findRankHeights = function(node, rank)
{
    if (this.maxRankHeight[rank] == null || this.maxRankHeight[rank] < node.height)
    {
        this.maxRankHeight[rank] = node.height;
    }

    var child = node.child;

    while (child != null)
    {
        this.findRankHeights(child, rank + 1);
        child = child.next;
    }
};

/**
 * Function: setCellHeights
 *
 * Set the cells heights (relative to the layout
 * direction) when the tops of each rank are to be aligned
 */
mxCompactTreeLayout.prototype.setCellHeights = function(node, rank)
{
    if (this.maxRankHeight[rank] != null && this.maxRankHeight[rank] > node.height)
    {
        node.height = this.maxRankHeight[rank];
    }

    var child = node.child;

    while (child != null)
    {
        this.setCellHeights(child, rank + 1);
        child = child.next;
    }
};

/**
 * Function: dfs
 *
 * Does a depth first search starting at the specified cell.
 * Makes sure the specified parent is never left by the
 * algorithm.
 */
mxCompactTreeLayout.prototype.dfs = function(cell, parent)
{
    var id = mxCellPath.create(cell);
    var node = null;

    if (cell != null && this.visited[id] == null && !this.isVertexIgnored(cell))
    {
        this.visited[id] = cell;
        node = this.createNode(cell);

        var model = this.graph.getModel();
        var prev = null;
        var out = this.graph.getEdges(cell, parent, this.invert, !this.invert, false, true);
        var view = this.graph.getView();

        if (this.sortEdges)
        {
            this.sortOutgoingEdges(cell, out);
        }

        for (var i = 0; i < out.length; i++)
        {
            var edge = out[i];

            if (!this.isEdgeIgnored(edge))
            {
                // Resets the points on the traversed edge
                if (this.resetEdges)
                {
                    this.setEdgePoints(edge, null);
                }

                if (this.edgeRouting)
                {
                    this.setEdgeStyleEnabled(edge, false);
                    this.setEdgePoints(edge, null);
                }

                // Checks if terminal in same swimlane
                var state = view.getState(edge);
                var target = (state != null) ? state.getVisibleTerminal(this.invert) : view.getVisibleTerminal(edge, this.invert);
                var tmp = this.dfs(target, parent);

                if (tmp != null && model.getGeometry(target) != null)
                {
                    if (prev == null)
                    {
                        node.child = tmp;
                    }
                    else
                    {
                        prev.next = tmp;
                    }

                    prev = tmp;
                }
            }
        }
    }

    return node;
};

/**
 * Function: layout
 *
 * Starts the actual compact tree layout algorithm
 * at the given node.
 */
mxCompactTreeLayout.prototype.layout = function(node)
{
    if (node != null)
    {
        var child = node.child;

        while (child != null)
        {
            this.layout(child);
            child = child.next;
        }

        if (node.child != null)
        {
            this.attachParent(node, this.join(node));
        }
        else
        {
            this.layoutLeaf(node);
        }
    }
};

/**
 * Function: horizontalLayout
 */
mxCompactTreeLayout.prototype.horizontalLayout = function(node, x0, y0, bounds)
{
    node.x += x0 + node.offsetX;
    node.y += y0 + node.offsetY;
    bounds = this.apply(node, bounds);
    var child = node.child;

    if (child != null)
    {
        bounds = this.horizontalLayout(child, node.x, node.y, bounds);
        var siblingOffset = node.y + child.offsetY;
        var s = child.next;

        while (s != null)
        {
            bounds = this.horizontalLayout(s, node.x + child.offsetX, siblingOffset, bounds);
            siblingOffset += s.offsetY;
            s = s.next;
        }
    }

    return bounds;
};

/**
 * Function: verticalLayout
 */
mxCompactTreeLayout.prototype.verticalLayout = function(node, parent, x0, y0, bounds)
{
    node.x += x0 + node.offsetY;
    node.y += y0 + node.offsetX;
    bounds = this.apply(node, bounds);
    var child = node.child;

    if (child != null)
    {
        bounds = this.verticalLayout(child, node, node.x, node.y, bounds);
        var siblingOffset = node.x + child.offsetY;
        var s = child.next;

        while (s != null)
        {
            bounds = this.verticalLayout(s, node, siblingOffset, node.y + child.offsetX, bounds);
            siblingOffset += s.offsetY;
            s = s.next;
        }
    }

    return bounds;
};

/**
 * Function: attachParent
 */
mxCompactTreeLayout.prototype.attachParent = function(node, height)
{
    var x = this.nodeDistance + this.levelDistance;
    var y2 = (height - node.width) / 2 - this.nodeDistance;
    var y1 = y2 + node.width + 2 * this.nodeDistance - height;

    node.child.offsetX = x + node.height;
    node.child.offsetY = y1;

    node.contour.upperHead = this.createLine(node.height, 0,
        this.createLine(x, y1, node.contour.upperHead));
    node.contour.lowerHead = this.createLine(node.height, 0,
        this.createLine(x, y2, node.contour.lowerHead));
};

/**
 * Function: layoutLeaf
 */
mxCompactTreeLayout.prototype.layoutLeaf = function(node)
{
    var dist = 2 * this.nodeDistance;

    node.contour.upperTail = this.createLine(
        node.height + dist, 0);
    node.contour.upperHead = node.contour.upperTail;
    node.contour.lowerTail = this.createLine(
        0, -node.width - dist);
    node.contour.lowerHead = this.createLine(
        node.height + dist, 0, node.contour.lowerTail);
};

/**
 * Function: join
 */
mxCompactTreeLayout.prototype.join = function(node)
{
    var dist = 2 * this.nodeDistance;

    var child = node.child;
    node.contour = child.contour;
    var h = child.width + dist;
    var sum = h;
    child = child.next;

    while (child != null)
    {
        var d = this.merge(node.contour, child.contour);
        child.offsetY = d + h;
        child.offsetX = 0;
        h = child.width + dist;
        sum += d + h;
        child = child.next;
    }

    return sum;
};

/**
 * Function: merge
 */
mxCompactTreeLayout.prototype.merge = function(p1, p2)
{
    var x = 0;
    var y = 0;
    var total = 0;

    var upper = p1.lowerHead;
    var lower = p2.upperHead;

    while (lower != null && upper != null)
    {
        var d = this.offset(x, y, lower.dx, lower.dy,
            upper.dx, upper.dy);
        y += d;
        total += d;

        if (x + lower.dx <= upper.dx)
        {
            x += lower.dx;
            y += lower.dy;
            lower = lower.next;
        }
        else
        {
            x -= upper.dx;
            y -= upper.dy;
            upper = upper.next;
        }
    }

    if (lower != null)
    {
        var b = this.bridge(p1.upperTail, 0, 0, lower, x, y);
        p1.upperTail = (b.next != null) ? p2.upperTail : b;
        p1.lowerTail = p2.lowerTail;
    }
    else
    {
        var b = this.bridge(p2.lowerTail, x, y, upper, 0, 0);

        if (b.next == null)
        {
            p1.lowerTail = b;
        }
    }

    p1.lowerHead = p2.lowerHead;

    return total;
};

/**
 * Function: offset
 */
mxCompactTreeLayout.prototype.offset = function(p1, p2, a1, a2, b1, b2)
{
    var d = 0;

    if (b1 <= p1 || p1 + a1 <= 0)
    {
        return 0;
    }

    var t = b1 * a2 - a1 * b2;

    if (t > 0)
    {
        if (p1 < 0)
        {
            var s = p1 * a2;
            d = s / a1 - p2;
        }
        else if (p1 > 0)
        {
            var s = p1 * b2;
            d = s / b1 - p2;
        }
        else
        {
            d = -p2;
        }
    }
    else if (b1 < p1 + a1)
    {
        var s = (b1 - p1) * a2;
        d = b2 - (p2 + s / a1);
    }
    else if (b1 > p1 + a1)
    {
        var s = (a1 + p1) * b2;
        d = s / b1 - (p2 + a2);
    }
    else
    {
        d = b2 - (p2 + a2);
    }

    if (d > 0)
    {
        return d;
    }
    else
    {
        return 0;
    }
};

/**
 * Function: bridge
 */
mxCompactTreeLayout.prototype.bridge = function(line1, x1, y1, line2, x2, y2)
{
    var dx = x2 + line2.dx - x1;
    var dy = 0;
    var s = 0;

    if (line2.dx == 0)
    {
        dy = line2.dy;
    }
    else
    {
        s = dx * line2.dy;
        dy = s / line2.dx;
    }

    var r = this.createLine(dx, dy, line2.next);
    line1.next = this.createLine(0, y2 + line2.dy - dy - y1, r);

    return r;
};

/**
 * Function: createNode
 */
mxCompactTreeLayout.prototype.createNode = function(cell)
{
    var node = new Object();
    node.cell = cell;
    node.x = 0;
    node.y = 0;
    node.width = 0;
    node.height = 0;

    var geo = this.getVertexBounds(cell);

    if (geo != null)
    {
        if (this.isHorizontal())
        {
            node.width = geo.height;
            node.height = geo.width;
        }
        else
        {
            node.width = geo.width;
            node.height = geo.height;
        }
    }

    node.offsetX = 0;
    node.offsetY = 0;
    node.contour = new Object();

    return node;
};

/**
 * Function: apply
 */
mxCompactTreeLayout.prototype.apply = function(node, bounds)
{
    var model = this.graph.getModel();
    var cell = node.cell;
    var g = model.getGeometry(cell);

    if (cell != null && g != null)
    {
        if (this.isVertexMovable(cell))
        {
            g = this.setVertexLocation(cell, node.x, node.y);

            if (this.resizeParent)
            {
                var parent = model.getParent(cell);
                var id = mxCellPath.create(parent);

                // Implements set semantic
                if (this.parentsChanged[id] == null)
                {
                    this.parentsChanged[id] = parent;
                }
            }
        }

        if (bounds == null)
        {
            bounds = new mxRectangle(g.x, g.y, g.width, g.height);
        }
        else
        {
            bounds = new mxRectangle(Math.min(bounds.x, g.x),
                Math.min(bounds.y, g.y),
                Math.max(bounds.x + bounds.width, g.x + g.width),
                Math.max(bounds.y + bounds.height, g.y + g.height));
        }
    }

    return bounds;
};

/**
 * Function: createLine
 */
mxCompactTreeLayout.prototype.createLine = function(dx, dy, next)
{
    var line = new Object();
    line.dx = dx;
    line.dy = dy;
    line.next = next;

    return line;
};

/**
 * Function: adjustParents
 *
 * Adjust parent cells whose child geometries have changed. The default
 * implementation adjusts the group to just fit around the children with
 * a padding.
 */
mxCompactTreeLayout.prototype.adjustParents = function()
{
    var tmp = [];

    for (var id in this.parentsChanged)
    {
        tmp.push(this.parentsChanged[id]);
    }

    this.arrangeGroups(mxUtils.sortCells(tmp, true), this.groupPadding, this.groupPaddingTop,
        this.groupPaddingRight, this.groupPaddingBottom, this.groupPaddingLeft);
};

/**
 * Function: localEdgeProcessing
 *
 * Moves the specified node and all of its children by the given amount.
 */
mxCompactTreeLayout.prototype.localEdgeProcessing = function(node)
{
    this.processNodeOutgoing(node);
    var child = node.child;

    while (child != null)
    {
        this.localEdgeProcessing(child);
        child = child.next;
    }
};

/**
 * Function: localEdgeProcessing
 *
 * Separates the x position of edges as they connect to vertices
 */
mxCompactTreeLayout.prototype.processNodeOutgoing = function(node)
{
    var child = node.child;
    var parentCell = node.cell;

    var childCount = 0;
    var sortedCells = [];

    while (child != null)
    {
        childCount++;

        var sortingCriterion = child.x;

        if (this.horizontal)
        {
            sortingCriterion = child.y;
        }

        sortedCells.push(new WeightedCellSorter(child, sortingCriterion));
        child = child.next;
    }

    sortedCells.sort(WeightedCellSorter.prototype.compare);

    var availableWidth = node.width;

    var requiredWidth = (childCount + 1) * this.prefHozEdgeSep;

    // Add a buffer on the edges of the vertex if the edge count allows
    if (availableWidth > requiredWidth + (2 * this.prefHozEdgeSep))
    {
        availableWidth -= 2 * this.prefHozEdgeSep;
    }

    var edgeSpacing = availableWidth / childCount;

    var currentXOffset = edgeSpacing / 2.0;

    if (availableWidth > requiredWidth + (2 * this.prefHozEdgeSep))
    {
        currentXOffset += this.prefHozEdgeSep;
    }

    var currentYOffset = this.minEdgeJetty - this.prefVertEdgeOff;
    var maxYOffset = 0;

    var parentBounds = this.getVertexBounds(parentCell);
    child = node.child;

    for (var j = 0; j < sortedCells.length; j++)
    {
        var childCell = sortedCells[j].cell.cell;
        var childBounds = this.getVertexBounds(childCell);

        var edges = this.graph.getEdgesBetween(parentCell,
            childCell, false);

        var newPoints = [];
        var x = 0;
        var y = 0;

        for (var i = 0; i < edges.length; i++)
        {
            if (this.horizontal)
            {
                // Use opposite co-ords, calculation was done for
                //
                x = parentBounds.x + parentBounds.width;
                y = parentBounds.y + currentXOffset;
                newPoints.push(new mxPoint(x, y));
                x = parentBounds.x + parentBounds.width
                    + currentYOffset;
                newPoints.push(new mxPoint(x, y));
                y = childBounds.y + childBounds.height / 2.0;
                newPoints.push(new mxPoint(x, y));
                this.setEdgePoints(edges[i], newPoints);
            }
            else
            {
                x = parentBounds.x + currentXOffset;
                y = parentBounds.y + parentBounds.height;
                newPoints.push(new mxPoint(x, y));
                y = parentBounds.y + parentBounds.height
                    + currentYOffset;
                newPoints.push(new mxPoint(x, y));
                x = childBounds.x + childBounds.width / 2.0;
                newPoints.push(new mxPoint(x, y));
                this.setEdgePoints(edges[i], newPoints);
            }
        }

        if (j < childCount / 2)
        {
            currentYOffset += this.prefVertEdgeOff;
        }
        else if (j > childCount / 2)
        {
            currentYOffset -= this.prefVertEdgeOff;
        }
        // Ignore the case if equals, this means the second of 2
        // jettys with the same y (even number of edges)

        //								pos[k * 2] = currentX;
        currentXOffset += edgeSpacing;
        //								pos[k * 2 + 1] = currentYOffset;

        maxYOffset = Math.max(maxYOffset, currentYOffset);
    }
};